type Observable[T] native // rx.Observable


public operator
    await[A,B] { o Observable[A], f Lambda[A,Observable[B]] } Observable[B]
    native('__Await')

public operator
    with[T] { o Observable[T], attached Observable[None] } Observable[T]
    native('__With')

public operator
    on-cancel[T] { o Observable[T], disposal Observable[None] } Observable[T]
    native('__OnCancel')

public operator
    scan[T,A] { o Observable[T], a A, f Lambda[Pair[A,T],A] } Observable[A]
    native('__ObservableScan')

public operator
    forever { o Observable[None] } Observable[None]
    native('__ObservableForever')

public operator variadic
    start-with[T] { o Observable[T], head List[T] } Observable[T]
    native('__ObservableStartWith')

public operator
    map[A,B] { o Observable[A], f Lambda[A,B] } Observable[B]
    native('__ObservableMap')

public operator
    map-to[A,B] { o Observable[A], value B } Observable[B]
    { (o map { => value }) }

public operator
    filter[T] { o Observable[T], f Lambda[T,Bool] } Observable[T]
    native('__ObservableFilter')

public operator
    deflate-map[A,B] { o Observable[A], f Lambda[A,Maybe[B]] } Observable[B]
    native('__ObservableDeflateMap')

public operator
    debounce-time[T] { o Observable[T], ms Int } Observable[T]
    native('__ObservableDebounce')

public operator
    switch-map[A,B] { o Observable[A], f Lambda[A,Observable[B]] } Observable[B]
    native('__ObservableSwitchMap')

public operator
    exhaust-map[A,B] { o Observable[A], f Lambda[A,Observable[B]] } Observable[B]
    native('__ObservableExhaustMap')

public operator
    merge-map[A,B] { o Observable[A], f Lambda[A,Observable[B]] } Observable[B]
    native('__ObservableMergeMap')

public operator
    concat-map[A,B] { o Observable[A], f Lambda[A,Observable[B]] } Observable[B]
    native('__ObservableConcatMap')

public operator
    mix-map[A,B] { o Observable[A], concurrent Int, f Lambda[A,Observable[B]] } Observable[B]
    native('__ObservableMixMap')

public function variadic
    Merge[T] { all List[Observable[T]] } Observable[T]
    native('__ObservableMerge')

public function variadic
    Concat[T] { all List[Observable[T]] } Observable[T]
    native('__ObservableConcat')

public operator
    distinct-until-changed[T] { o Observable[T] } { == Lambda[Pair[T,T],Bool] } Observable[T]
    native('__ObservableDistinctUntilChanged')

public operator
    with-latest-from[T,A] { o Observable[T], another Observable[A] } Observable[Pair[T,Maybe[A]]]
    native('__ObservableWithLatestFrom')

public operator
    combine-latest[A,B] { a Observable[A], b Observable[B] } Observable[Pair[A,B]]
    native('__ObservableCombineLatest')

public operator
    combine-latest[A,B,C] { a Observable[A], b Observable[B], c Observable[C] } Observable[Triple[A,B,C]]
    native('__ObservableCombineLatest')


